package body Sigma is

   -----------
   -- creer --
   -----------

   function creer return Model is
   begin
      return new Model_Term
        '(The_Builder => creer);
   end creer;

   --------------
   -- inscrire --
   --------------

   function inscrire (x : Model; n : individu) return Model is
   begin
      return new Model_Term
        '(The_Builder => inscrire,
          inscrire_x => x,
          inscrire_n => new Individu'(n));
   end inscrire;

   -----------------
   -- est_inscrit --
   -----------------

   function est_inscrit (x : Model; n : individu) return boolean is
   begin
      case x.all.The_Builder is
         when creer =>
            return  false;
         when inscrire =>
            if x.all.inscrire_n.all = n then
               return true;
            else
               return est_inscrit(x.all.inscrire_x, n);
            end if;
         when bloquer =>
            return est_inscrit(x.all.bloquer_x, n);
         when debloquer =>
            return est_inscrit(x.all.debloquer_x, n);
         when ajouter_cercle =>
            return est_inscrit(x.all.ajouter_cercle_x, n);
         when retirer_cercle =>
            return est_inscrit(x.all.retirer_cercle_x, n);
         when ajouter_membre =>
            return est_inscrit(x.all.ajouter_membre_x, n);
         when retirer_membre =>
            return est_inscrit(x.all.retirer_membre_x, n);
         when poster =>
            return est_inscrit(x.all.poster_x, n);
         when commenter =>
            return est_inscrit(x.all.commenter_x, n);
      end case;
   end est_inscrit;

   ---------------------
   -- nombre_inscrits --
   ---------------------

   function nombre_inscrits (x : Model) return natural is
   begin
      case x.all.The_Builder is
         when creer =>
            return 0;
         when inscrire =>
            return nombre_inscrits(x.all.inscrire_x)+1;
         when bloquer =>
            return nombre_inscrits(x.all.bloquer_x);
         when debloquer =>
            return nombre_inscrits(x.all.debloquer_x);
         when ajouter_cercle =>
            return nombre_inscrits(x.all.ajouter_cercle_x);
         when retirer_cercle =>
            return nombre_inscrits(x.all.retirer_cercle_x);
         when ajouter_membre =>
            return nombre_inscrits(x.all.ajouter_membre_x);
         when retirer_membre =>
            return nombre_inscrits(x.all.retirer_membre_x);
         when poster =>
            return nombre_inscrits(x.all.poster_x);
         when commenter =>
            return nombre_inscrits(x.all.commenter_x);
      end case;
   end nombre_inscrits;

   ------------------
   -- ieme_inscrit --
   ------------------

   function ieme_inscrit (x : Model; i : natural) return individu is
      begin
         case x.all.The_Builder is
         when creer => raise Program_Error;
         when inscrire =>
            if i <= nombre_inscrits(x.all.inscrire_x) then
               if ieme_inscrit(x.all.inscrire_x, i) <= x.all.inscrire_n.all then
                  return ieme_inscrit(x.all.inscrire_x, i);
               elsif i = 1 then
                  return x.all.inscrire_n.all;
               elsif ieme_inscrit(x.all.inscrire_x, i - 1) <= x.all.inscrire_n.all then
                  return x.all.inscrire_n.all;
               else
                  return ieme_inscrit(x.all.inscrire_x, i - 1);
               end if;
            elsif i = 1 then
               return x.all.inscrire_n.all;
            elsif ieme_inscrit(x.all.inscrire_x, i - 1) <= x.all.inscrire_n.all then
               return x.all.inscrire_n.all;
            else
               return ieme_inscrit(x.all.inscrire_x, i - 1);
            end if;
         when bloquer =>
            return ieme_inscrit(x.all.bloquer_x, i);
         when debloquer =>
            return ieme_inscrit(x.all.debloquer_x, i);
         when ajouter_cercle =>
            return ieme_inscrit(x.all.ajouter_cercle_x, i);
         when retirer_cercle =>
            return ieme_inscrit(x.all.retirer_cercle_x, i);
         when ajouter_membre =>
            return ieme_inscrit(x.all.ajouter_membre_x, i);
         when retirer_membre =>
            return ieme_inscrit(x.all.retirer_membre_x, i);
         when poster =>
            return ieme_inscrit(x.all.poster_x, i);
         when commenter =>
            return ieme_inscrit(x.all.commenter_x, i);
      end case;
   end ieme_inscrit;

   -------------
   -- bloquer --
   -------------

   function bloquer (x : Model; m : individu; n : individu) return Model is
   begin
      return new Model_Term
        '(The_Builder => bloquer,
          bloquer_x => x,
          bloquer_m => new Individu'(m),
          bloquer_n => new Individu'(n));
   end bloquer;

   ---------------
   -- debloquer --
   ---------------

   function debloquer (x : Model; m : individu; n : individu) return Model is
   begin
      return new Model_Term
        '(The_Builder => debloquer,
          debloquer_x => x,
          debloquer_m => new Individu'(m),
          debloquer_n => new Individu'(n));
   end debloquer;

   ----------------
   -- est_bloque --
   ----------------

   function est_bloque
     (x : Model;
      m : individu;
      n : individu)
      return boolean
   is
   begin
      case x.all.The_Builder is
         when creer =>
            return false;
         when inscrire =>
            return est_bloque(x.all.inscrire_x, m, n);
         when bloquer =>
            if x.all.bloquer_m.all <= m and m <= x.all.bloquer_m.all and x.all.bloquer_n.all <= n and n <= x.all.bloquer_n.all then
               return true;
            else
               return est_bloque(x.all.bloquer_x, m, n);
            end if;
         when debloquer =>
            if x.all.debloquer_m.all <= m and m <= x.all.debloquer_m.all and x.all.debloquer_n.all <= n and n <= x.all.debloquer_n.all then
               return false;
            else
               return est_bloque(x.all.debloquer_x, m, n);
            end if;
         when ajouter_cercle =>
            return est_bloque(x.all.ajouter_cercle_x, m, n);
         when retirer_cercle =>
            return est_bloque(x.all.retirer_cercle_x, m, n);
         when ajouter_membre =>
            return est_bloque(x.all.ajouter_membre_x, m, n);
         when retirer_membre =>
            return est_bloque(x.all.retirer_membre_x, m, n);
         when poster =>
            return est_bloque(x.all.poster_x, m, n);
         when commenter =>
            return est_bloque(x.all.commenter_x, m, n);
      end case;
   end est_bloque;

   -------------------
   -- est_cercle_de --
   -------------------

   function est_cercle_de
     (x : Model;
      n : individu;
      c : cercle)
      return boolean
   is
   begin
      case x.all.The_Builder is
         when creer =>
            return false;
         when inscrire =>
            if x.all.inscrire_n.all <= n and n <= x.all.inscrire_n.all then
               return false;
            else
               return est_cercle_de(x.all.inscrire_x, n ,c);
            end if;
         when bloquer =>
            return est_cercle_de(x.all.bloquer_x, n, c);
         when debloquer =>
            return est_cercle_de(x.all.debloquer_x, n, c);
         when ajouter_cercle =>
            if x.all.ajouter_cercle_c.all <= c and c <= x.all.ajouter_cercle_c.all and x.all.ajouter_cercle_n.all <= n and n <= x.all.ajouter_cercle_n.all then
               return true;
            else
               return est_cercle_de(x.all.ajouter_cercle_x, n, c);
            end if;
         when retirer_cercle =>
            if x.all.retirer_cercle_c.all <= c and c <= x.all.retirer_cercle_c.all and x.all.retirer_cercle_n.all <= n and n <= x.all.retirer_cercle_n.all then
               return false;
            else
               return est_cercle_de(x.all.retirer_cercle_x, n ,c);
            end if;
         when ajouter_membre =>
            return est_cercle_de(x.all.ajouter_membre_x, n, c);
         when retirer_membre =>
            return est_cercle_de(x.all.retirer_membre_x, n, c);
         when poster =>
            return est_cercle_de(x.all.poster_x, n ,c);
         when commenter =>
            return est_cercle_de(x.all.commenter_x, n ,c);
      end case;
   end est_cercle_de;

   --------------------
   -- ajouter_cercle --
   --------------------

   function ajouter_cercle
     (x : Model;
      n : individu;
      c : cercle)
      return Model
   is
   begin
      return new Model_Term
        '(The_Builder => ajouter_cercle,
          ajouter_cercle_x => x,
          ajouter_cercle_n => new Individu'(n),
          ajouter_cercle_c => new Cercle'(c));
   end ajouter_cercle;

   --------------------
   -- retirer_cercle --
   --------------------

   function retirer_cercle
     (x : Model;
      n : individu;
      c : cercle)
      return Model
   is
   begin
      return new Model_Term
        '(The_Builder => retirer_cercle,
          retirer_cercle_x => x,
          retirer_cercle_n => new Individu'(n),
          retirer_cercle_c => new Cercle'(c));
   end retirer_cercle;

   -----------------------
   -- nombre_cercles_de --
   -----------------------

   function nombre_cercles_de (x : Model; n : individu) return natural is
   begin
      case x.all.The_Builder is
         when creer =>
            return 0;
         when inscrire =>
            if x.all.inscrire_n.all <= n and n <= x.all.inscrire_n.all then
               return 0;
            else
               return nombre_cercles_de(x.all.inscrire_x, n);
            end if;
         when bloquer =>
            return nombre_cercles_de(x.all.bloquer_x, n);
         when debloquer =>
            return nombre_cercles_de(x.all.debloquer_x, n);
         when ajouter_cercle =>
            if x.all.ajouter_cercle_n.all <= n and n <= x.all.ajouter_cercle_n.all then
               return nombre_cercles_de(x.all.ajouter_cercle_x, n) + 1;
            else
               return nombre_cercles_de(x.all.ajouter_cercle_x, n);
               end if;
         when retirer_cercle =>
            if x.all.retirer_cercle_n.all <= n and n <= x.all.retirer_cercle_n.all then
               return nombre_cercles_de(x.all.retirer_cercle_x, n) - 1;
            else
               return nombre_cercles_de(x.all.retirer_cercle_x, n);
            end if;
         when ajouter_membre =>
            return nombre_cercles_de(x.all.ajouter_membre_x, n);
         when retirer_membre =>
            return nombre_cercles_de(x.all.retirer_membre_x, n);
         when poster =>
            return nombre_cercles_de(x.all.poster_x, n);
         when commenter =>
            return nombre_cercles_de(x.all.commenter_x, n);
      end case;
   end nombre_cercles_de;

   -----------------
   -- ieme_cercle --
   -----------------

   function ieme_cercle
     (x : Model;
      n : individu;
      i : natural)
      return cercle
   is
   begin
      case x.all.The_Builder is
         when creer => raise Program_Error;
         when inscrire =>
            return ieme_cercle(x.all.inscrire_x, n, i);
         when bloquer =>
            return ieme_cercle(x.all.bloquer_x, n, i);
         when debloquer =>
            return ieme_cercle(x.all.debloquer_x, n, i);
         when ajouter_cercle =>
            if x.all.ajouter_cercle_n.all <= n and n <= x.all.ajouter_cercle_n.all then
               if i <= nombre_cercles_de(x.all.ajouter_cercle_x, n) then
                  if ieme_cercle(x.all.ajouter_cercle_x, n, i) <= x.all.ajouter_cercle_c.all then
                     return ieme_cercle(x.all.ajouter_cercle_x, n, i);
                  elsif i = 1 then
                     return x.all.ajouter_cercle_c.all;
                  elsif ieme_cercle(x.all.ajouter_cercle_x, n, i - 1) <= x.all.ajouter_cercle_c.all then
                     return x.all.ajouter_cercle_c.all;
                  else
                     return ieme_cercle(x.all.ajouter_cercle_x, n, i - 1);
                  end if;
               elsif i = 1 then
                  return x.all.ajouter_cercle_c.all;
               elsif ieme_cercle(x.all.ajouter_cercle_x, n, i - 1) <= x.all.ajouter_cercle_c.all then
                  return x.all.ajouter_cercle_c.all;
               else
                  return ieme_cercle(x.all.ajouter_cercle_x, n, i - 1);
               end if;
            else
               return ieme_cercle(x.all.ajouter_cercle_x, n, i);
            end if;
         when retirer_cercle =>
            if x.all.retirer_cercle_n.all <= n and n <= x.all.retirer_cercle_n.all then
               if x.all.retirer_cercle_c.all <= ieme_cercle(x.all.retirer_cercle_x, n, i) then
                  return ieme_cercle(x.all.retirer_cercle_x, n, i + 1);
               else
                  return ieme_cercle(x.all.retirer_cercle_x, n, i);
               end if;
            else
               return ieme_cercle(x.all.retirer_cercle_x, n, i);
            end if;
            when ajouter_membre =>
            return ieme_cercle(x.all.ajouter_membre_x, n, i);
         when retirer_membre =>
            return ieme_cercle(x.all.retirer_membre_x, n, i);
         when poster =>
            return ieme_cercle(x.all.poster_x, n, i);
         when commenter =>
            return ieme_cercle(x.all.commenter_x, n, i);
      end case;
   end ieme_cercle;

   -------------------
   -- est_membre_de --
   -------------------

   function est_membre_de
     (x : Model;
      m : individu;
      c : cercle;
      n : individu)
      return boolean
   is
   begin
      case x.all.The_Builder is
         when creer =>
            return false;
         when inscrire =>
            return est_membre_de(x.all.inscrire_x, m, c, n);
         when bloquer =>
            if x.all.bloquer_m.all <= m and m <= x.all.bloquer_m.all and x.all.bloquer_n.all <= n and n <= x.all.bloquer_n.all then
               return false;
            else
               return est_membre_de(x.all.bloquer_x, m, c, n);
            end if;
         when debloquer =>
            return est_membre_de(x.all.debloquer_x, m, c, n);
         when ajouter_cercle =>
            if x.all.ajouter_cercle_n.all <= m and m <= x.all.ajouter_cercle_n.all and x.all.ajouter_cercle_c.all <= c and c <= x.all.ajouter_cercle_c.all then
               return false;
            else
               return est_membre_de(x.all.ajouter_cercle_x, m, c, n);
            end if;
         when retirer_cercle =>
            if x.all.retirer_cercle_n.all <= m and m <= x.all.retirer_cercle_n.all and x.all.retirer_cercle_c.all <= c and c <= x.all.retirer_cercle_c.all then
               return false;
            else
               return est_membre_de(x.all.retirer_cercle_x, m, c, n);
            end if;
         when ajouter_membre =>
            if x.all.ajouter_membre_n.all <= m and m <= x.all.ajouter_membre_n.all and x.all.ajouter_membre_c.all <= c and c <= x.all.ajouter_membre_c.all and x.all.ajouter_membre_p.all <= n and n <= x.all.ajouter_membre_p.all then
               return true;
            else
               return est_membre_de(x.all.ajouter_membre_x, m, c, n);
            end if;
         when retirer_membre =>
            if x.all.retirer_membre_n.all <= m and m <= x.all.retirer_membre_n.all and x.all.retirer_membre_c.all <= c and c <= x.all.retirer_membre_c.all and x.all.retirer_membre_p.all <= n and n <= x.all.retirer_membre_p.all then
               return false;
            else
               return est_membre_de(x.all.retirer_membre_x, m, c, n);
            end if;
         when poster =>
            return est_membre_de(x.all.poster_x, m, c, n);
         when commenter =>
            return est_membre_de(x.all.commenter_x, m, c, n);
      end case;
   end est_membre_de;

   --------------------
   -- ajouter_membre --
   --------------------

   function ajouter_membre
     (x : Model;
      n : individu;
      c : cercle;
      p : individu)
      return Model
   is
   begin
      return new Model_Term
        '(The_Builder => ajouter_membre,
          ajouter_membre_x => x,
          ajouter_membre_n => new Individu'(n),
          ajouter_membre_c => new Cercle'(c),
          ajouter_membre_p => new Individu'(p));
   end ajouter_membre;

   --------------------
   -- retirer_membre --
   --------------------

   function retirer_membre
     (x : Model;
      n : individu;
      c : cercle;
      p : individu)
      return Model
   is
   begin
      return new Model_Term
        '(The_Builder => retirer_membre,
          retirer_membre_x => x,
          retirer_membre_n => new Individu'(n),
          retirer_membre_c => new Cercle'(c),
          retirer_membre_p => new Individu'(p));
   end retirer_membre;

   -----------------------
   -- nombre_membres_de --
   -----------------------

   function nombre_membres_de
     (x : Model;
      n : individu;
      c : cercle)
      return natural
   is
   begin
      case x.all.The_Builder is
         when creer =>
            return 0;
         when inscrire =>
            return nombre_membres_de(x.all.inscrire_x, n, c);
         when bloquer =>
            if x.all.bloquer_m.all <= n and n <= x.all.bloquer_m.all and est_membre_de(x, n, c, x.all.bloquer_n.all) then
               return nombre_membres_de(x.all.bloquer_x, n, c) - 1;
            else
               return nombre_membres_de(x.all.bloquer_x, n, c);
            end if;
         when debloquer =>
            return nombre_membres_de(x.all.debloquer_x, n, c);
         when ajouter_cercle =>
            if x.all.ajouter_cercle_n.all <= n and n <= x.all.ajouter_cercle_n.all and x.all.ajouter_cercle_c.all <= c and c <= x.all.ajouter_cercle_c.all then
               return 0;
            else
               return nombre_membres_de(x.all.ajouter_cercle_x, n, c);
            end if;
         when retirer_cercle =>
            if x.all.retirer_cercle_n.all <= n and n <= x.all.retirer_cercle_n.all and x.all.retirer_cercle_c.all <= c and c <= x.all.retirer_cercle_c.all then
               return 0;
            else
               return nombre_membres_de(x.all.retirer_cercle_x, n, c);
            end if;
         when ajouter_membre =>
            if x.all.ajouter_membre_n.all <= n and n <= x.all.ajouter_membre_n.all and x.all.ajouter_membre_c.all <= c and c <= x.all.ajouter_membre_c.all then
               return nombre_membres_de(x.all.ajouter_membre_x, n, c) + 1;
            else
               return nombre_membres_de(x.all.ajouter_membre_x, n, c);
            end if;
         when retirer_membre =>
            if x.all.retirer_membre_n.all <= n and n <= x.all.retirer_membre_n.all and x.all.retirer_membre_c.all <= c and c <= x.all.retirer_membre_c.all then
               return nombre_membres_de(x.all.retirer_membre_x, n, c) - 1;
            else
               return nombre_membres_de(x.all.retirer_membre_x, n, c);
            end if;
         when poster =>
            return nombre_membres_de(x.all.poster_x, n, c);
         when commenter =>
            return nombre_membres_de(x.all.commenter_x, n, c);
      end case;
   end nombre_membres_de;

   -----------------
   -- ieme_membre --
   -----------------

   function ieme_membre
     (x : Model;
      n : individu;
      c : cercle;
      i : natural)
      return individu
   is
   begin
      case x.all.The_Builder is
         when creer => raise Program_Error;
         when inscrire =>
            return ieme_membre(x.all.inscrire_x, n, c, i);
         when bloquer =>
            if x.all.bloquer_m.all <= n and n <= x.all.bloquer_m.all and est_membre_de(x, n, c, x.all.bloquer_n.all) then
               if x.all.bloquer_n.all <= ieme_membre(x.all.bloquer_x, n, c, i) then
                  return ieme_membre(x.all.bloquer_x, n, c, i + 1);
               else
                  return ieme_membre(x.all.bloquer_x, n, c, i);
               end if;
            else
               return ieme_membre(x.all.bloquer_x, n, c, i);
            end if;
         when debloquer =>
            return ieme_membre(x.all.debloquer_x, n, c, i);
         when ajouter_cercle =>
            return ieme_membre(x.all.ajouter_cercle_x, n, c, i);
         when retirer_cercle =>
            return ieme_membre(x.all.retirer_cercle_x, n, c, i);
         when ajouter_membre =>
            if x.all.ajouter_membre_n.all <= n and n <= x.all.ajouter_membre_n.all and x.all.ajouter_membre_c.all <= c and c <= x.all.ajouter_membre_c.all then
               if i <= nombre_membres_de(x.all.ajouter_membre_x, n, c) then
                  if ieme_membre(x.all.ajouter_membre_x, n, c, i) <= x.all.ajouter_membre_p.all then
                     return ieme_membre(x.all.ajouter_membre_x, n, c, i);
                  elsif i = 1 then
                     return x.all.ajouter_membre_p.all;
                  elsif ieme_membre(x.all.ajouter_membre_x, n, c, i - 1) <= x.all.ajouter_membre_p.all then
                     return x.all.ajouter_membre_p.all;
                  else
                     return ieme_membre(x.all.ajouter_membre_x, n, c, i - 1);
                  end if;
               elsif i = 1 then
                  return x.all.ajouter_membre_p.all;
               elsif ieme_membre(x.all.ajouter_membre_x, n, c, i - 1) <= x.all.ajouter_membre_p.all then
                  return x.all.ajouter_membre_p.all;
               else
                  return ieme_membre(x.all.ajouter_membre_x, n, c, i - 1);
               end if;
            else
               return ieme_membre(x.all.ajouter_membre_x, n, c, i);
            end if;
         when retirer_membre =>
            if x.all.retirer_membre_n.all <= n and n <= x.all.retirer_membre_n.all and est_membre_de(x.all.retirer_membre_x, n, c, x.all.retirer_membre_p.all) then
               if x.all.retirer_membre_p.all <= ieme_membre(x.all.retirer_membre_x, n, c, i) then
                  return ieme_membre(x.all.retirer_membre_x, n, c, i + 1);
               else
                  return ieme_membre(x.all.retirer_membre_x, n, c, i);
               end if;
            else
               return ieme_membre(x.all.retirer_membre_x, n, c, i);
            end if;
         when poster =>
            return ieme_membre(x.all.poster_x, n, c, i);
         when commenter =>
            return ieme_membre(x.all.commenter_x, n, c, i);
      end case;
   end ieme_membre;

   ------------
   -- poster --
   ------------

   function poster
     (x : Model;
      n : individu;
      c : cercle;
      t : texte)
      return Model
   is
   begin
      return new Model_Term
        '(The_Builder => poster,
          poster_x => x,
          poster_n => new Individu'(n),
          poster_c => new Cercle'(c),
          poster_t => new Texte'(t));
   end poster;

   ---------------
   -- commenter --
   ---------------

   function commenter
     (x : Model;
      n : individu;
      i : natural;
      t : texte)
      return Model
   is
   begin
      return new Model_Term
        '(The_Builder => commenter,
          commenter_x => x,
          commenter_n => new Individu'(n),
          commenter_i => new Natural'(i),
          commenter_t => new Texte'(t));
   end commenter;

   ------------------
   -- nombre_posts --
   ------------------

   function nombre_posts (x : Model) return natural is
   begin
      case x.all.The_Builder is
         when creer =>
            return 0;
         when inscrire =>
            return nombre_posts(x.all.inscrire_x);
         when bloquer =>
            return nombre_posts(x.all.bloquer_x);
         when debloquer =>
            return nombre_posts(x.all.debloquer_x);
         when ajouter_cercle =>
            return nombre_posts(x.all.ajouter_cercle_x);
         when retirer_cercle =>
            return nombre_posts(x.all.retirer_cercle_x);
         when ajouter_membre =>
            return nombre_posts(x.all.ajouter_membre_x);
         when retirer_membre =>
            return nombre_posts(x.all.retirer_membre_x);
         when poster =>
            return nombre_posts(x.all.poster_x) + 1;
         when commenter =>
            return nombre_posts(x.all.commenter_x);
      end case;
   end nombre_posts;

   ---------------
   -- consulter --
   ---------------

   function consulter (x : Model; n : individu) return mur is
   begin
      case x.all.The_Builder is
         when creer => raise Program_Error;
         when inscrire =>
            if x.all.inscrire_n.all <= n and n <= x.all.inscrire_n.all then
               return creer(n);
            else
               return consulter(x.all.inscrire_x, n);
            end if;
         when bloquer =>
            return consulter(x.all.bloquer_x, n);
         when debloquer =>
            return consulter(x.all.debloquer_x, n);
         when ajouter_cercle =>
            return consulter(x.all.ajouter_cercle_x, n);
         when retirer_cercle =>
            return consulter(x.all.retirer_cercle_x, n);
         when ajouter_membre =>
            return consulter(x.all.ajouter_membre_x, n);
         when retirer_membre =>
            return consulter(x.all.retirer_membre_x, n);
         when poster =>
            if (est_membre_de(x.all.poster_x, x.all.poster_n.all, x.all.poster_c.all, n) and not est_bloque(x.all.poster_x, n, x.all.poster_n.all)) or (x.all.poster_n.all <= n and n <= x.all.poster_n.all) then
               return afficher(consulter(x.all.poster_x, n), x.all.poster_n.all, x.all.poster_t.all, nombre_posts(x.all.poster_x) + 1);
            else
               return consulter(x.all.poster_x, n);
            end if;
         when commenter =>
            if est_defini(consulter(x.all.commenter_x, n), x.all.commenter_i.all) and ((x.all.commenter_n.all <= n and n <= x.all.commenter_n.all) or not (est_bloque(x.all.commenter_x, auteur(consulter(x.all.commenter_x, n), x.all.commenter_i.all), x.all.commenter_n.all) or est_bloque(x, x.all.commenter_n.all, n) or est_bloque(x.all.commenter_x, n, x.all.commenter_n.all))) then
               return afficher(consulter(x.all.commenter_x, n), x.all.commenter_n.all, x.all.commenter_t.all, x.all.commenter_i.all);
            else
               return consulter(x.all.commenter_x, n);
            end if;
      end case;
   end consulter;

end Sigma;
